home *** CD-ROM | disk | FTP | other *** search
/ Network Supervisor's Toolkit / Network Supervisor's Toolkit.iso / tools / lu62 / debug / ftt6.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-10  |  9.8 KB  |  454 lines
  1. /*
  2.  *  CopyRight 1995. Nicholas Poljakov all rights reserved.
  3.  */
  4. #include <dos.h>
  5. #include <bios.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <malloc.h>
  9.  
  10. #define BORDER 1
  11. #define REV_VID 0x70
  12. #define NORM_VID 0x1E
  13. #define MAX_FRAME 31
  14. #define BKSP 8
  15. #define F1 59
  16. #define F2 60
  17. #define F3 61
  18. #define F4 62
  19. #define F5 63
  20. #define F6 64
  21. #define F7 65
  22. #define F8 66
  23. #define F9 67
  24. #define F10 68
  25. #define HM  71   /* Home key     */
  26. #define UP  72   /* Up Arrow     */
  27. #define PU  73   /* Page Up      */
  28. #define LT  75   /* Left Arrow   */
  29. #define RT  77   /* Right Arrow  */
  30. #define END 79   /* End key      */
  31. #define DN  80   /* Down Arrow   */
  32. #define PD  81   /* Page Down    */
  33. #define ESC '\033'
  34. #define DIR 0x10
  35.  
  36. #define ROWS1 19
  37. #define ROWS2 23
  38. #define ROWS  25
  39. #define COLS 78
  40. #define L_W 20
  41. #define M_W 36
  42. #define R_W 20
  43. #define SCRNSIZE ((ROWS)*(COLS+2)*2)
  44. #define LAST (24 * 80)*2
  45.  
  46. #define M0C  4     /* Files maping col.s */
  47. #define M0L  14    /* Files maping rows  */
  48. #define M0F (((80 * 5) + 9)) * 2
  49. #define INTR 18*2
  50.  
  51. extern unsigned char cur_off;
  52. extern unsigned int attr1b;
  53. extern unsigned int *ptrs;
  54. extern int size;
  55. extern unsigned char row, col;
  56. extern int adapter;
  57. extern unsigned char far *videomem;
  58. extern int offset;
  59. extern int sw;
  60. extern char *path;
  61. extern char file[12];
  62. extern char tpname[31];
  63. extern char luname[8];
  64. extern char mode_name[8];
  65. extern char rcv_file[12];
  66. extern char dta[128];
  67.  
  68. extern char far *sv;
  69. extern char far *vid_mem;
  70. extern short cur_ln;
  71.  
  72. extern struct menu_frame {
  73.     int startx, endx, starty, endy;
  74.     unsigned char *p;
  75.     char **menu;
  76.     char *keys;
  77.     int border;
  78.     int count;
  79.     unsigned char attrib;
  80.     int active;
  81.     int curx, cury;
  82.     char *header;
  83.     unsigned char shd;
  84.     } frame[MAX_FRAME];
  85.  
  86. extern char p_dcl[21];
  87. extern unsigned char dr_ind[80];
  88. extern char c_pt[60];
  89. extern int drive_ind[10];
  90.  
  91. sfs(t, f)
  92. char far *t;
  93. char far *f;
  94. {
  95.     unsigned fs;
  96.     unsigned fo;
  97.     unsigned ts;
  98.     unsigned to;
  99.  
  100.     fs = FP_SEG( f );
  101.     fo = FP_OFF( f );
  102.  
  103.     ts = FP_SEG( t );
  104.     to = FP_OFF( t );
  105.  
  106.     _asm {
  107.             push si
  108.             push di
  109.             push ds
  110.             mov  si, word ptr fo[0]
  111.             mov  di, word ptr to[0]
  112.             mov  ax, word ptr ts[0]
  113.             mov  es, ax
  114.             mov  ax, word ptr fs[0]
  115.             mov  ds, ax
  116.         mov  cx, 2000
  117.             cld
  118.         rep  movsw
  119.             pop  ds
  120.             pop  di
  121.             pop  si
  122.     }
  123.  
  124.     return 0;
  125. }
  126. window(num)
  127. int num;
  128. {
  129.     int choice, x, y;
  130.     int dl;
  131.  
  132.     if (!frame[num].active) {
  133.     sfs(sv, vid_mem);
  134.         if (frame[num].shd) {
  135.             dl = 1;
  136.         }
  137.         else
  138.             dl = 0;
  139.         if ((frame[num].p = malloc(2*(frame[num].endx-frame[num].startx+1+dl)*(frame[num].endy-frame[num].starty+1+dl))) == NULL) {
  140.             return -1;
  141.         }
  142.         save_video(num);
  143.         if (frame[num].border) {
  144.             draw_border(num);
  145.         }
  146.         display_header(num);
  147.         x = frame[num].startx + frame[num].curx + 1;
  148.         y = frame[num].starty + frame[num].cury + 1;
  149.         goto_xy(x, y);
  150.         frame[num].active = 1;
  151.     }
  152.     return 0;
  153. }
  154.  
  155. display_header(num)
  156. int num;
  157. {
  158.     register int y, len;
  159.  
  160.     y = frame[num].starty;
  161.     len = strlen(frame[num].header);
  162.     if (len == 0) return 0;
  163.     len = (frame[num].endy - y - len) / 2;
  164.     if (len <= 0) {
  165.         return -1;
  166.     }
  167.     y = y + len;
  168.     write_string(frame[num].startx, y, frame[num].header, NORM_VID);
  169.     return 0;
  170. }
  171.  
  172. deactivate(num)
  173. int num;
  174. {
  175.     if (frame[num].active) {
  176.         frame[num].curx = 0;
  177.         frame[num].cury = 0;
  178.         restore_video(num);
  179.         free(frame[num].p);
  180.     }
  181.     return 0;
  182. }
  183. window_xy(num, x, y)
  184. int num, x, y;
  185. {
  186.  
  187.     if ((x<0)||(x+frame[num].startx >= frame[num].endx - 1)) {
  188.     return 0;
  189.     }
  190.     if ((y<0)||(y+frame[num].starty >= frame[num].endy - 1)) {
  191.     return 0;
  192.     }
  193.     frame[num].curx = x;
  194.     frame[num].cury = y;
  195.     if (!cur_off) {
  196.        goto_xy(frame[num].startx + x + 1,  frame[num].starty + y + 1);
  197.     }
  198.     return 1;
  199. }
  200. unsigned window_getche(int num)
  201. {
  202.     union inkey {
  203.         char ch[2];
  204.     unsigned i;
  205.         } c;
  206.  
  207.         if (!frame[num].active) {
  208.             return 0;
  209.         }
  210.         window_xy(num, frame[num].curx, frame[num].cury);
  211.     c.i = _bios_keybrd( _KEYBRD_READ );
  212.         if (c.ch[0]) {
  213.             switch (c.ch[0]) {
  214.                 case '\r' :
  215.                              break;
  216.                 case BKSP :
  217.                              break;
  218.                 case 0:      return c.i;
  219.                 default:
  220.                  if (frame[num].cury+frame[num].starty < frame[num].endy-1) {
  221.                                 write_char(frame[num].startx+frame[num].curx+1,
  222.                                 frame[num].starty+frame[num].cury+1,
  223.                                 c.ch[0], frame[num].attrib);
  224.                                 frame[num].cury++;
  225.                              }
  226.              }
  227.              if (frame[num].curx < 0) {
  228.                 frame[num].curx = 0;
  229.              }
  230.              if (frame[num].curx+frame[num].startx > frame[num].endx-2) {
  231.         frame[num].curx--;
  232.              }
  233.              window_xy(num, frame[num].curx, frame[num].cury);
  234.         }
  235.         return c.i;
  236. }
  237.  
  238. unsigned window_gets(int num, char *s)
  239. {
  240.     char *temp;
  241.     union inkey {
  242.         char ch[2];
  243.     unsigned i;
  244.         } c;
  245.  
  246.     temp = s;
  247.     for (;;) {
  248.         c.i = window_getche(num);
  249.     switch (c.ch[0]) {
  250.         case ESC :
  251.              if (s == temp) {
  252.                  s++;
  253.                  clear_back(temp, s, num);
  254.                              return 1;
  255.                          }
  256.              else  {
  257.                   s++;
  258.                   while (s != temp) {
  259.                      clear_back(temp, s, num);
  260.                      s--;
  261.                   }
  262.                 }
  263.                          break;
  264.             case '\r' :
  265.                          *s = '\0';
  266.                          return 0;
  267.             case BKSP :
  268.              clear_back(temp, s, num);
  269.              s--;
  270.              break;
  271.             case 0:      return c.i;
  272.         default :     *s = c.ch[0];
  273.              s++;
  274.      }
  275.     }
  276.     return 0;
  277. }
  278. clear_back(temp, s, num)
  279. char *temp;
  280. char *s;
  281. int num;
  282. {
  283.         if (s > temp) {
  284.            s--;
  285.            frame[num].cury--;
  286.            if (frame[num].cury < 0) {
  287.                frame[num].cury = 0;
  288.            }
  289.            window_xy(num, frame[num].curx, frame[num].cury);
  290.            write_char(frame[num].startx + frame[num].curx + 1,
  291.                    frame[num].starty + frame[num].cury + 1, ' ',frame[num].attrib);
  292.         }
  293. }
  294. window_putchar(num, ch)
  295. int num;
  296. char ch;
  297. {
  298.     register int x, y;
  299.     char far *v;
  300.  
  301.     if (!frame[num].active) {
  302.         return 0;
  303.     }
  304.     x = frame[num].curx + frame[num].startx + 1;
  305.     y = frame[num].cury + frame[num].starty + 1;
  306.     v = vid_mem;
  307.     v += (x*160) + y*2;
  308.     if (y > frame[num].endy) {
  309.         return 1;
  310.     }
  311.     if (x > frame[num].endx) {
  312.     return 1;
  313.     }
  314.     if (ch == '\n') {
  315.         x++;
  316.         y = frame[num].startx + 1;
  317.         v = vid_mem;
  318.         v += (x*160) + y*2;
  319.         frame[num].curx++;
  320.         frame[num].cury = 0;
  321.     }
  322.     else
  323.             {
  324.                 frame[num].cury++;
  325.                 *v++ = ch;
  326.                 *v++ = frame[num].attrib;
  327.             }
  328.     window_xy(num, frame[num].curx, frame[num].cury);
  329.     return 1;
  330. }
  331.  
  332. window_puts(num, str)
  333. int num;
  334. char *str;
  335. {
  336.     if (!frame[num].active) {
  337.         return 0;
  338.     }
  339.     for (; *str; str++) {
  340.         window_putchar(num, *str);
  341.     }
  342.     return 1;
  343. }
  344.  
  345. window_cls(num)
  346. int num;
  347. {
  348.     register int i, j;
  349.     char far *v, far *t;
  350.  
  351.     v = vid_mem;
  352.     t = v;
  353.     for (i = frame[num].startx+1; i < frame[num].endy; i++) {
  354.         for (j = frame[num].starty+1; j < frame[num].endx; j++) {
  355.             v = t;
  356.             v += (j*160) + i*2;
  357.             *v++ = ' ';
  358.             *v = NORM_VID;
  359.         }
  360.     }
  361.     frame[num].curx = 0;
  362.     frame[num].cury = 0;
  363. }
  364.  
  365. window_cleol(num)
  366. int num;
  367. {
  368.     register int i, x, y;
  369.  
  370.     x = frame[num].curx;
  371.     y = frame[num].cury;
  372.     window_xy(num, frame[num].curx, frame[num].cury);
  373.     for (i = frame[num].cury; i < frame[num].endy - 1; i++) {
  374.         window_putchar(num, ' ');
  375.     }
  376.     window_xy(num, x, y);
  377. }
  378.  
  379. window_upline(num)
  380. int num;
  381. {
  382.     if (frame[num].curx > 0) {
  383.         frame[num].curx--;
  384.         window_xy(num, frame[num].curx, frame[num].cury);
  385.         return 1;
  386.     }
  387.     return 0;
  388. }
  389.  
  390. window_downline(num)
  391. int num;
  392. {
  393.     if (frame[num].curx < (frame[num].endx - frame[num].startx - 1)) {
  394.         frame[num].curx++;
  395.         window_xy(num, frame[num].curx, frame[num].cury);
  396.         return 1;
  397.     }
  398.     return 1;
  399. }
  400.  
  401. window_bksp(num)
  402. int num;
  403. {
  404.     if (frame[num].cury > 0) {
  405.         frame[num].cury--;
  406.         window_xy(num, frame[num].curx, frame[num].cury);
  407.         window_putchar(num, ' ');
  408.         frame[num].cury--;
  409.         window_xy(num, frame[num].curx, frame[num].cury);
  410.     }
  411.     return 0;
  412. }
  413.  
  414. make_window(num, header, startx, starty, endx, endy, border, attrib, shi)
  415. int num;
  416. char *header;
  417. int startx, starty, endx, endy;
  418. int border;
  419. unsigned char attrib, shi;
  420.  
  421. {
  422.     unsigned char *p;
  423.     int dl;
  424.  
  425.     if (num > MAX_FRAME) {
  426.         return -1;
  427.     }
  428.     if ((startx>24)||(startx<0)||(starty>78)||(starty<0)) {
  429.         return -1;
  430.     }
  431.     if ((endx>24)||(endy>79)) {
  432.         return -1;
  433.     }
  434.     if (shi) {
  435.         dl = 1;
  436.     }
  437.     else
  438.         dl = 0;
  439.     frame[num].startx = startx;
  440.     frame[num].endx = endx;
  441.     frame[num].starty = starty;
  442.     frame[num].endy = endy;
  443.     frame[num].p = p;
  444.     frame[num].header = header;
  445.     frame[num].border = border;
  446.     frame[num].active = 0;
  447.     frame[num].attrib = attrib;
  448.     frame[num].curx = 0;
  449.     frame[num].cury = 0;
  450.     frame[num].shd = shi;
  451.  
  452.     return 0;
  453. }
  454.